Use the new sysprof collector api to do tracing.
#mesondefine HAVE_SYS_PARAM_H
/* Have the sysprof-capture library */
-#mesondefine HAVE_SYSPROF_CAPTURE
+#mesondefine HAVE_SYSPROF
/* Define to 1 if you have the <sys/stat.h> header file. */
#mesondefine HAVE_SYS_STAT_H
#include "gdkversionmacros.h"
-#include "gdkprofilerprivate.h"
#include "gdkinternals.h"
#include "gdkintl.h"
g_warning ("GDK_DEBUG set but ignored because GTK isn't built with G_ENABLE_DEBUG");
#endif /* G_ENABLE_DEBUG */
- if (g_getenv ("GTK_TRACE_FD"))
- gdk_profiler_start (atoi (g_getenv ("GTK_TRACE_FD")));
- else if (g_getenv ("GTK_TRACE"))
- gdk_profiler_start (-1);
-
#ifndef G_HAS_CONSTRUCTORS
stash_desktop_startup_notification_id ();
#endif
g_object_class_install_properties (gobject_class, LAST_PROP, pspecs);
}
-#ifdef G_ENABLE_DEBUG
static guint pixels_counter;
-#endif
static void
gdk_draw_context_init (GdkDrawContext *self)
{
-#ifdef G_ENABLE_DEBUG
if (pixels_counter == 0)
pixels_counter = gdk_profiler_define_int_counter ("frame pixels", "Pixels drawn per frame");
-#endif
}
/**
GDK_DRAW_CONTEXT_GET_CLASS (context)->begin_frame (context, priv->frame_region);
}
-#ifdef G_ENABLE_DEBUG
+#ifdef HAVE_SYSPROF
static gint64
region_get_pixels (cairo_region_t *region)
{
GDK_DRAW_CONTEXT_GET_CLASS (context)->end_frame (context, priv->frame_region);
-#ifdef G_ENABLE_DEBUG
- if (GDK_PROFILER_IS_RUNNING)
- gdk_profiler_set_int_counter (pixels_counter,
- g_get_monotonic_time (),
- region_get_pixels (priv->frame_region));
-#endif
+ gdk_profiler_set_int_counter (pixels_counter, region_get_pixels (priv->frame_region));
g_clear_pointer (&priv->frame_region, cairo_region_destroy);
g_clear_object (&priv->surface->paint_context);
void
_gdk_frame_clock_emit_update (GdkFrameClock *frame_clock)
{
- gint64 before = g_get_monotonic_time ();
+ gint64 before G_GNUC_UNUSED;
+
+ before = GDK_PROFILER_CURRENT_TIME;
g_signal_emit (frame_clock, signals[UPDATE], 0);
- if (GDK_PROFILER_IS_RUNNING)
- gdk_profiler_end_mark (before, "frameclock update", NULL);
+ gdk_profiler_end_mark (before, "frameclock update", NULL);
}
void
_gdk_frame_clock_emit_layout (GdkFrameClock *frame_clock)
{
- gint64 before = g_get_monotonic_time ();
+ gint64 before G_GNUC_UNUSED;
+
+ before = GDK_PROFILER_CURRENT_TIME;
g_signal_emit (frame_clock, signals[LAYOUT], 0);
- if (GDK_PROFILER_IS_RUNNING)
- gdk_profiler_end_mark (before, "frameclock layout", NULL);
+ gdk_profiler_end_mark (before, "frameclock layout", NULL);
}
void
_gdk_frame_clock_emit_paint (GdkFrameClock *frame_clock)
{
- gint64 before = g_get_monotonic_time ();
+ gint64 before G_GNUC_UNUSED;
+
+ before = GDK_PROFILER_CURRENT_TIME;
g_signal_emit (frame_clock, signals[PAINT], 0);
- if (GDK_PROFILER_IS_RUNNING)
- gdk_profiler_end_mark (before, "frameclock paint", NULL);
+ gdk_profiler_end_mark (before, "frameclock paint", NULL);
}
void
g_signal_emit (frame_clock, signals[RESUME_EVENTS], 0);
}
+#ifdef HAVE_SYSPROF
static gint64
guess_refresh_interval (GdkFrameClock *frame_clock)
{
interval = guess_refresh_interval (frame_clock);
if (interval == 0)
return 0.0;
- }
-
+ }
+
return ((double) end_counter - start_counter) * G_USEC_PER_SEC / (end_timestamp - start_timestamp);
}
+#endif
void
_gdk_frame_clock_add_timings_to_profiler (GdkFrameClock *clock,
GdkFrameTimings *timings)
{
if (timings->drawn_time != 0)
- gdk_profiler_add_mark (timings->drawn_time, 0, "drawn window", NULL);
+ {
+ gdk_profiler_add_mark (1000 * timings->drawn_time, 0, "drawn window", NULL);
+ }
if (timings->presentation_time != 0)
- gdk_profiler_add_mark (timings->presentation_time, 0, "presented window", NULL);
-
- if (timings->presentation_time != 0 || timings->drawn_time != 0)
{
- gint64 time = timings->presentation_time != 0 ? timings->presentation_time : timings->drawn_time;
- gdk_profiler_set_counter (fps_counter, time, frame_clock_get_fps (clock));
+ gdk_profiler_add_mark (1000 * timings->presentation_time, 0, "presented window", NULL);
}
+
+ gdk_profiler_set_counter (fps_counter, frame_clock_get_fps (clock));
}
for details. */
gint64 sleep_serial;
- gint64 freeze_time;
+ gint64 freeze_time; /* in microseconds */
guint flush_idle_id;
guint paint_idle_id;
GdkFrameClockIdlePrivate *priv = clock_idle->priv;
gboolean skip_to_resume_events;
GdkFrameTimings *timings = NULL;
- gint64 before = g_get_monotonic_time ();
+ gint64 before G_GNUC_UNUSED;
+
+ before = GDK_PROFILER_CURRENT_TIME;
priv->paint_idle_id = 0;
priv->in_paint_idle = TRUE;
if (priv->freeze_count == 0)
priv->sleep_serial = get_sleep_serial ();
- if (GDK_PROFILER_IS_RUNNING)
- gdk_profiler_end_mark (before, "frameclock cycle", NULL);
+ gdk_profiler_end_mark (before, "frameclock cycle", NULL);
return FALSE;
}
{
if (priv->freeze_time != 0)
{
- gdk_profiler_end_mark (priv->freeze_time,
- "frameclock frozen", NULL);
+ gdk_profiler_end_mark (priv->freeze_time * 1000, "frameclock frozen", NULL);
priv->freeze_time = 0;
}
}
#include "config.h"
+#include "gdkprofilerprivate.h"
+
#include <sys/types.h>
#include <signal.h>
#endif
#include "gdkversionmacros.h"
-#include "gdkprofilerprivate.h"
#include "gdkframeclockprivate.h"
-#ifdef HAVE_SYSPROF_CAPTURE
-
-#include <sysprof-capture.h>
-
-static SysprofCaptureWriter *writer = NULL;
-static gboolean running = FALSE;
-
-static void
-profiler_stop (int s)
-{
- if (writer)
- sysprof_capture_writer_unref (writer);
-}
-
-void
-gdk_profiler_start (int fd)
-{
- if (writer)
- return;
-
- sysprof_clock_init ();
-
- if (fd == -1)
- {
- char *filename;
-
- filename = g_strdup_printf ("gtk.%d.syscap", getpid ());
- g_print ("Writing profiling data to %s\n", filename);
- writer = sysprof_capture_writer_new (filename, 16*1024);
- g_free (filename);
- }
- else if (fd > 2)
- writer = sysprof_capture_writer_new_from_fd (fd, 16*1024);
-
- if (writer)
- running = TRUE;
-
- atexit (G_CALLBACK (profiler_stop));
- signal (SIGTERM, profiler_stop);
-}
-
-void
-gdk_profiler_stop (void)
-{
- running = FALSE;
-}
gboolean
gdk_profiler_is_running (void)
{
- return running;
+#ifdef HAVE_SYSPROF
+ return sysprof_collector_is_active ();
+#else
+ return FALSE;
+#endif
}
void
-gdk_profiler_add_mark (gint64 start,
- guint64 duration,
- const char *name,
- const char *message)
+(gdk_profiler_add_mark) (gint64 begin_time,
+ gint64 duration,
+ const char *name,
+ const char *message)
{
- if (!running)
- return;
-
- sysprof_capture_writer_add_mark (writer,
- start * 1000L,
- -1, getpid (),
- duration * 1000L,
- "gtk", name, message);
+#ifdef HAVE_SYSPROF
+ sysprof_collector_mark (begin_time, duration, "gtk", name, message);
+#endif
}
-static void add_markvf (gint64 start,
- guint64 duration,
- const char *name,
- const char *format,
- va_list args) G_GNUC_PRINTF(4, 0);
-
-static void
-add_markvf (gint64 start,
- guint64 duration,
- const char *name,
- const char *format,
- va_list args)
+void
+(gdk_profiler_end_mark) (gint64 begin_time,
+ const char *name,
+ const char *message)
{
- char *message;
- message = g_strdup_vprintf (format, args);
- sysprof_capture_writer_add_mark (writer,
- start * 1000L,
- -1, getpid (),
- duration * 1000L,
- "gtk", name, message);
- g_free (message);
+#ifdef HAVE_SYSPROF
+ sysprof_collector_mark (begin_time, GDK_PROFILER_CURRENT_TIME - begin_time, "gtk", name, message);
+#endif
}
void
-gdk_profiler_add_markf (gint64 start,
- guint64 duration,
- const char *name,
- const char *format,
- ...)
+(gdk_profiler_add_markf) (gint64 begin_time,
+ gint64 duration,
+ const gchar *name,
+ const gchar *message_format,
+ ...)
{
+#ifdef HAVE_SYSPROF
va_list args;
-
- if (!running)
- return;
-
- va_start (args, format);
- add_markvf (start, duration, name, format, args);
+ va_start (args, message_format);
+ sysprof_collector_mark_vprintf (begin_time, duration, "gtk", name, message_format, args);
va_end (args);
+#endif /* HAVE_SYSPROF */
}
void
-gdk_profiler_end_mark (gint64 start,
- const char *name,
- const char *message)
-{
- if (!running)
- return;
-
- sysprof_capture_writer_add_mark (writer,
- start * 1000L,
- -1, getpid (),
- (g_get_monotonic_time () - start) * 1000L,
- "gtk", name, message);
-}
-
-void
-gdk_profiler_end_markf (gint64 start,
- const char *name,
- const char *format,
- ...)
+(gdk_profiler_end_markf) (gint64 begin_time,
+ const gchar *name,
+ const gchar *message_format,
+ ...)
{
+#ifdef HAVE_SYSPROF
va_list args;
-
- if (!running)
- return;
-
- va_start (args, format);
- add_markvf (start, g_get_monotonic_time () - start, name, format, args);
+ va_start (args, message_format);
+ sysprof_collector_mark_vprintf (begin_time, GDK_PROFILER_CURRENT_TIME - begin_time, "gtk", name, message_format, args);
va_end (args);
+#endif /* HAVE_SYSPROF */
}
-
-static guint
-define_counter (const char *name,
- const char *description,
- int type)
+guint
+(gdk_profiler_define_counter) (const char *name,
+ const char *description)
{
+#ifdef HAVE_SYSPROF
SysprofCaptureCounter counter;
- if (!writer)
- return 0;
-
- counter.id = (guint) sysprof_capture_writer_request_counter (writer, 1);
- counter.type = type;
- counter.value.vdbl = 0;
+ counter.id = sysprof_collector_request_counters (1);
+ counter.type = SYSPROF_CAPTURE_COUNTER_DOUBLE;
+ counter.value.vdbl = 0.0;
g_strlcpy (counter.category, "gtk", sizeof counter.category);
g_strlcpy (counter.name, name, sizeof counter.name);
g_strlcpy (counter.description, description, sizeof counter.name);
- sysprof_capture_writer_define_counters (writer,
- SYSPROF_CAPTURE_CURRENT_TIME,
- -1,
- getpid (),
- &counter,
- 1);
+ sysprof_collector_define_counters (&counter, 1);
return counter.id;
+#else
+ return 0;
+#endif
}
guint
-gdk_profiler_define_counter (const char *name,
- const char *description)
+(gdk_profiler_define_int_counter) (const char *name,
+ const char *description)
{
- return define_counter (name, description, SYSPROF_CAPTURE_COUNTER_DOUBLE);
-}
+#ifdef HAVE_SYSPROF
+ SysprofCaptureCounter counter;
-guint
-gdk_profiler_define_int_counter (const char *name,
- const char *description)
-{
- return define_counter (name, description, SYSPROF_CAPTURE_COUNTER_INT64);
+ counter.id = sysprof_collector_request_counters (1);
+ counter.type = SYSPROF_CAPTURE_COUNTER_INT64;
+ counter.value.v64 = 0;
+ g_strlcpy (counter.category, "gtk", sizeof counter.category);
+ g_strlcpy (counter.name, name, sizeof counter.name);
+ g_strlcpy (counter.description, description, sizeof counter.name);
+
+ sysprof_collector_define_counters (&counter, 1);
+
+ return counter.id;
+#else
+ return 0;
+#endif
}
void
-gdk_profiler_set_counter (guint id,
- gint64 time,
- double val)
+(gdk_profiler_set_counter) (guint id,
+ double val)
{
+#ifdef HAVE_SYSPROF
SysprofCaptureCounterValue value;
- if (!running)
- return;
-
value.vdbl = val;
- sysprof_capture_writer_set_counters (writer,
- time * 1000L,
- -1, getpid (),
- &id, &value, 1);
+ sysprof_collector_set_counters (&id, &value, 1);
+#endif
}
void
-gdk_profiler_set_int_counter (guint id,
- gint64 time,
- gint64 val)
+(gdk_profiler_set_int_counter) (guint id,
+ gint64 val)
{
+#ifdef HAVE_SYSPROF
SysprofCaptureCounterValue value;
- if (!running)
- return;
-
value.v64 = val;
- sysprof_capture_writer_set_counters (writer,
- time * 1000L,
- -1, getpid (),
- &id, &value, 1);
-}
-
-#else
-
-void
-gdk_profiler_start (int fd)
-{
-}
-
-void
-gdk_profiler_stop (void)
-{
-}
-
-gboolean
-gdk_profiler_is_running (void)
-{
- return FALSE;
-}
-
-void
-gdk_profiler_add_mark (gint64 start,
- guint64 duration,
- const char *name,
- const char *message)
-{
-}
-
-void
-gdk_profiler_add_markf (gint64 start,
- guint64 duration,
- const char *name,
- const char *format,
- ...)
-{
-}
-
-void
-gdk_profiler_end_mark (gint64 start,
- const char *name,
- const char *message)
-{
-}
-
-void
-gdk_profiler_end_markf (gint64 start,
- const char *name,
- const char *format,
- ...)
-{
-}
-
-guint
-gdk_profiler_define_counter (const char *name,
- const char *description)
-{
- return 0;
-}
-
-void
-gdk_profiler_set_counter (guint id,
- gint64 time,
- double value)
-{
-}
-
-guint
-gdk_profiler_define_int_counter (const char *name,
- const char *description)
-{
- return 0;
-}
-
-void
-gdk_profiler_set_int_counter (guint id,
- gint64 time,
- gint64 value)
-{
+ sysprof_collector_set_counters (&id, &value, 1);
+#endif
}
-
-#endif /* G_OS_WIN32 */
#include "gdk/gdkframeclock.h"
#include "gdk/gdkdisplay.h"
-G_BEGIN_DECLS
-
/* Ensure we included config.h as needed for the below HAVE_SYSPROF_CAPTURE check */
#ifndef GETTEXT_PACKAGE
#error "config.h was not included before gdkprofilerprivate.h."
#endif
-/* We make this a macro you use as if (GDK_PROFILER_IS_RUNNING) because that
- * way we can ensure all the code is compiled out when not supported, and
- * we can add a G_UNLIKELY() for better codegen if it is.
- */
-#ifdef HAVE_SYSPROF_CAPTURE
-#define GDK_PROFILER_IS_RUNNING G_UNLIKELY (gdk_profiler_is_running ())
+#ifdef HAVE_SYSPROF
+#include <sysprof-capture.h>
+#endif
+
+G_BEGIN_DECLS
+
+#ifdef HAVE_SYSPROF
+#define GDK_PROFILER_IS_RUNNING (gdk_profiler_is_running ())
+#define GDK_PROFILER_CURRENT_TIME SYSPROF_CAPTURE_CURRENT_TIME
#else
-#define GDK_PROFILER_IS_RUNNING FALSE
+#define GDK_PROFILER_IS_RUNNING 0
+#define GDK_PROFILER_CURRENT_TIME 0
#endif
-void gdk_profiler_start (int fd);
-void gdk_profiler_stop (void);
gboolean gdk_profiler_is_running (void);
-void gdk_profiler_add_mark (gint64 start,
- guint64 duration,
- const char *name,
- const char *message);
-void gdk_profiler_add_markf (gint64 start,
- guint64 duration,
- const char *name,
- const char *format,
- ...) G_GNUC_PRINTF (4, 5);
-void gdk_profiler_end_mark (gint64 start,
- const char *name,
- const char *message);
-void gdk_profiler_end_markf (gint64 start,
- const char *name,
- const char *format,
- ...) G_GNUC_PRINTF (3, 4);
-guint gdk_profiler_define_counter (const char *name,
- const char *description);
-void gdk_profiler_set_counter (guint id,
- gint64 time,
- double value);
-guint gdk_profiler_define_int_counter (const char *name,
- const char *description);
-void gdk_profiler_set_int_counter (guint id,
- gint64 time,
- gint64 value);
+
+/* Note: Times and durations are in nanoseconds;
+ * g_get_monotonic_time(), and GdkFrameClock times
+ * are in microseconds, so multiply by 1000.
+ */
+void gdk_profiler_add_mark (gint64 begin_time,
+ gint64 duration,
+ const gchar *name,
+ const gchar *message);
+void gdk_profiler_add_markf (gint64 begin_time,
+ gint64 duration,
+ const gchar *name,
+ const gchar *message_format,
+ ...) G_GNUC_PRINTF (4, 5);
+void gdk_profiler_end_mark (gint64 begin_time,
+ const gchar *name,
+ const gchar *message);
+void gdk_profiler_end_markf (gint64 begin_time,
+ const gchar *name,
+ const gchar *message_format,
+ ...) G_GNUC_PRINTF (3, 4);
+
+guint gdk_profiler_define_counter (const char *name,
+ const char *description);
+guint gdk_profiler_define_int_counter (const char *name,
+ const char *description);
+void gdk_profiler_set_counter (guint id,
+ double value);
+void gdk_profiler_set_int_counter (guint id,
+ gint64 value);
+
+#ifndef HAVE_SYSPROF
+#define gdk_profiler_add_mark(b, d, n, m)
+#define gdk_profiler_end_mark(b, n, m)
+/* Optimise the whole call out */
+#if defined(G_HAVE_ISO_VARARGS)
+#define gdk_profiler_add_markf(b, d, n, m, ...)
+#define gdk_profiler_end_markf(b, n, m, ...)
+#elif defined(G_HAVE_GNUC_VARARGS)
+#define gdk_profiler_add_markf(b, d, n, m...)
+#define gdk_profiler_end_markf(b, n, m...)
+#else
+/* no varargs macro support; the call will have to be optimised out by the compiler */
+#endif
+
+#define gdk_profiler_define_counter(n, d) 0
+#define gdk_profiler_define_int_counter(n, d) 0
+#define gdk_profiler_set_counter(i, v)
+#define gdk_profiler_set_int_counter(i, v)
+#endif
G_END_DECLS
return FALSE;
}
-static void
+static inline void
add_event_mark (GdkEvent *event,
gint64 time,
- guint64 duration)
+ gint64 end_time)
{
+#ifdef HAVE_SYSPROF
char *message = NULL;
const char *kind;
GEnumClass *class;
break;
}
- gdk_profiler_add_mark (time, duration, "event", message ? message : kind);
+ gdk_profiler_add_mark (time, end_time - time, "event", message ? message : kind);
g_free (message);
+#endif
}
gboolean
gdk_surface_handle_event (GdkEvent *event)
{
- gint64 begin_time = g_get_monotonic_time ();
+ gint64 begin_time = GDK_PROFILER_CURRENT_TIME;
gboolean handled = FALSE;
if (check_autohide (event))
}
if (GDK_PROFILER_IS_RUNNING)
- add_event_mark (event, begin_time, g_get_monotonic_time () - begin_time);
+ add_event_mark (event, begin_time, GDK_PROFILER_CURRENT_TIME);
return handled;
}
guint size;
const char *name;
GValue v = G_VALUE_INIT;
- gint64 before = g_get_monotonic_time ();
+ gint64 before G_GNUC_UNUSED;
+
+ before = GDK_PROFILER_CURRENT_TIME;
g_assert (display_wayland);
g_assert (display_wayland->shm);
gdk_wayland_display_set_cursor_theme (GDK_DISPLAY (display_wayland), name, size);
g_value_unset (&v);
- if (GDK_PROFILER_IS_RUNNING)
- gdk_profiler_end_mark (before, "wayland", "load cursor theme");
+ gdk_profiler_end_mark (before, "wayland", "load cursor theme");
}
gdk_wayland_surface_sync (surface);
gdk_wayland_surface_request_frame (surface);
- gdk_profiler_add_mark (g_get_monotonic_time (), 0, "wayland", "swap buffers");
+ gdk_profiler_add_mark (GDK_PROFILER_CURRENT_TIME, 0, "wayland", "swap buffers");
if (display_wayland->have_egl_swap_buffers_with_damage)
{
int i, j, n_rects = cairo_region_num_rectangles (painted);
GdkFrameClock *clock = gdk_surface_get_frame_clock (surface);
GdkFrameTimings *timings;
- gdk_profiler_add_mark (g_get_monotonic_time (), 0, "wayland", "frame event");
+ gdk_profiler_add_mark (GDK_PROFILER_CURRENT_TIME, 0, "wayland", "frame event");
GDK_DISPLAY_NOTE (GDK_DISPLAY (display_wayland), EVENTS, g_message ("frame %p", surface));
wl_callback_destroy (callback);
* before we need to stage any changes, then we can take it back and
* use it again.
*/
- gdk_profiler_add_mark (g_get_monotonic_time (), 0, "wayland", "surface commit");
+ gdk_profiler_add_mark (GDK_PROFILER_CURRENT_TIME, 0, "wayland", "surface commit");
wl_surface_commit (impl->display_server.wl_surface);
impl->pending_commit = FALSE;
maybe_set_gtk_surface_dbus_properties (surface);
maybe_set_gtk_surface_modal (surface);
- gdk_profiler_add_mark (g_get_monotonic_time (), 0, "wayland", "surface commit");
+ gdk_profiler_add_mark (GDK_PROFILER_CURRENT_TIME, 0, "wayland", "surface commit");
wl_surface_commit (impl->display_server.wl_surface);
}
}
}
- gdk_profiler_add_mark (g_get_monotonic_time (), 0, "wayland", "surface commit");
+ gdk_profiler_add_mark (GDK_PROFILER_CURRENT_TIME, 0, "wayland", "surface commit");
wl_surface_commit (impl->display_server.wl_surface);
if (GDK_IS_POPUP (surface))
_gdk_x11_surface_grab_check_unmap (surface, xevent->xany.serial);
- if (GDK_PROFILER_IS_RUNNING)
- gdk_profiler_add_markf (g_get_monotonic_time (), 0, "unmapped window", "0x%lx", GDK_SURFACE_XID (surface));
+ gdk_profiler_add_markf (GDK_PROFILER_CURRENT_TIME, 0, "unmapped window", "0x%lx", GDK_SURFACE_XID (surface));
}
break;
GError **error)
{
GskGLRenderer *self = GSK_GL_RENDERER (renderer);
- gint64 before = g_get_monotonic_time ();
+ gint64 before G_GNUC_UNUSED;
+ before = GDK_PROFILER_CURRENT_TIME;
/* If we didn't get a GdkGLContext before realization, try creating
* one now, for our exclusive use.
*/
self->icon_cache = get_icon_cache_for_display (gdk_surface_get_display (surface), self->atlases);
gsk_gl_shadow_cache_init (&self->shadow_cache);
- if (GDK_PROFILER_IS_RUNNING)
- gdk_profiler_end_mark (before, "gl renderer realize", NULL);
+ gdk_profiler_end_mark (before, "gl renderer realize", NULL);
return TRUE;
}
graphene_matrix_t projection;
#ifdef G_ENABLE_DEBUG
GskProfiler *profiler;
- gint64 gpu_time, cpu_time, start_time;
+ gint64 gpu_time, cpu_time;
+ gint64 start_time G_GNUC_UNUSED;
#endif
GPtrArray *removed;
gsk_profiler_push_samples (profiler);
- if (GDK_PROFILER_IS_RUNNING)
- gdk_profiler_add_mark (start_time, cpu_time, "GL render", "");
-
+ gdk_profiler_add_mark (start_time * 1000, cpu_time * 1000, "GL render", "");
#endif
}
GdkTexture *texture;
#ifdef G_ENABLE_DEBUG
GskProfiler *profiler;
- gint64 cpu_time, start_time;
+ gint64 cpu_time;
+ gint64 start_time G_GNUC_UNUSED;
#endif
#ifdef G_ENABLE_DEBUG
if (GDK_PROFILER_IS_RUNNING)
{
- gdk_profiler_add_mark (start_time, cpu_time, "render", "");
+ gdk_profiler_add_mark (start_time * 1000, cpu_time * 1000, "render", "");
gdk_profiler_set_int_counter (texture_pixels_counter,
- start_time + cpu_time,
gsk_profiler_counter_get (profiler, self->profile_counters.texture_pixels));
gdk_profiler_set_int_counter (fallback_pixels_counter,
- start_time + cpu_time,
gsk_profiler_counter_get (profiler, self->profile_counters.fallback_pixels));
}
#endif
{
GtkApplication *application = GTK_APPLICATION (g_application);
GtkApplicationPrivate *priv = gtk_application_get_instance_private (application);
- gint64 before = g_get_monotonic_time ();
- gint64 before2;
+ gint64 before G_GNUC_UNUSED;
+ gint64 before2 G_GNUC_UNUSED;
+
+ before = GDK_PROFILER_CURRENT_TIME;
G_APPLICATION_CLASS (gtk_application_parent_class)->startup (g_application);
gtk_action_muxer_insert (priv->muxer, "app", G_ACTION_GROUP (application));
- before2 = g_get_monotonic_time ();
+ before2 = GDK_PROFILER_CURRENT_TIME;
gtk_init ();
- if (GDK_PROFILER_IS_RUNNING)
- gdk_profiler_end_mark (before2, "gtk init", NULL);
+ gdk_profiler_end_mark (before2, "gtk init", NULL);
priv->impl = gtk_application_impl_new (application, gdk_display_get_default ());
gtk_application_impl_startup (priv->impl, priv->register_session);
gtk_application_load_resources (application);
- if (GDK_PROFILER_IS_RUNNING)
- gdk_profiler_end_mark (before, "gtk application startup", NULL);
+ gdk_profiler_end_mark (before, "gtk application startup", NULL);
}
static void
const char * domain;
ParserData data;
GSList *l;
- gint64 before = g_get_monotonic_time ();
+ gint64 before = GDK_PROFILER_CURRENT_TIME;
/* Store the original domain so that interface domain attribute can be
* applied for the builder and the original domain can be restored after
if (GDK_PROFILER_IS_RUNNING)
{
- guint64 after = g_get_monotonic_time ();
- if (after - before > 500)
- gdk_profiler_add_mark (before, after - before, "builder load", filename);
+ guint64 after = GDK_PROFILER_CURRENT_TIME;
+ if (after - before > 500000) /* half a millisecond */
+ {
+ gdk_profiler_add_mark (before, after - before, "builder load", filename);
+ }
}
}
{
GtkCountingBloomFilter filter = GTK_COUNTING_BLOOM_FILTER_INIT;
gint64 timestamp;
- gint64 before = g_get_monotonic_time ();
+ gint64 before G_GNUC_UNUSED;
+
+ before = GDK_PROFILER_CURRENT_TIME;
g_assert (cssnode->parent == NULL);
if (GDK_PROFILER_IS_RUNNING)
{
- gint64 after = g_get_monotonic_time ();
- gdk_profiler_add_mark (before, (after - before), "css validation", "");
- gdk_profiler_set_int_counter (invalidated_nodes_counter, after, invalidated_nodes);
- gdk_profiler_set_int_counter (created_styles_counter, after, created_styles);
+ gdk_profiler_end_mark (before, "css validation", "");
+ gdk_profiler_set_int_counter (invalidated_nodes_counter, invalidated_nodes);
+ gdk_profiler_set_int_counter (created_styles_counter, created_styles);
invalidated_nodes = 0;
created_styles = 0;
}
GtkCssProviderPrivate *priv = gtk_css_provider_get_instance_private (css_provider);
GtkCssSelectorTreeBuilder *builder;
guint i;
- gint64 before = g_get_monotonic_time ();
+ gint64 before G_GNUC_UNUSED;
+
+ before = GDK_PROFILER_CURRENT_TIME;
g_array_sort (priv->rulesets, gtk_css_provider_compare_rule);
}
#endif
- if (GDK_PROFILER_IS_RUNNING)
- gdk_profiler_end_mark (before, "create selector tree", NULL);
+ gdk_profiler_end_mark (before, "create selector tree", NULL);
}
static void
GFile *file,
GBytes *bytes)
{
- gint64 before = g_get_monotonic_time ();
+ gint64 before G_GNUC_UNUSED;
+
+ before = GDK_PROFILER_CURRENT_TIME;
if (bytes == NULL)
{
{
GtkEmojiChooser *chooser = data;
GVariant *item;
- guint64 start, now;
+ gint64 start, now;
- start = g_get_monotonic_time ();
+ start = GDK_PROFILER_CURRENT_TIME;
if (!chooser->data)
{
add_emoji (chooser->box, FALSE, item, 0, chooser);
g_variant_unref (item);
- now = g_get_monotonic_time ();
- if (now > start + 8000)
+ now = GDK_PROFILER_CURRENT_TIME;
+ if (now > start + 2000000) /* 2 ms */
{
- if (GDK_PROFILER_IS_RUNNING)
- gdk_profiler_add_mark (start, (now - start), "emojichooser", "populate");
+ gdk_profiler_add_mark (start, (now - start), "emojichooser", "populate");
return G_SOURCE_CONTINUE;
}
}
chooser->box = NULL;
chooser->populate_idle = 0;
- if (GDK_PROFILER_IS_RUNNING)
- gdk_profiler_end_mark (start, "emojichooser", "populate (finish)");
+ gdk_profiler_end_mark (start, "emojichooser", "populate (finish)");
return G_SOURCE_REMOVE;
}
if (!self->themes_valid)
{
- gint64 before;
+ gint64 before G_GNUC_UNUSED;
+
if (non_blocking)
return FALSE;
- before = g_get_monotonic_time ();
+ before = GDK_PROFILER_CURRENT_TIME;
load_themes (self);
- if (GDK_PROFILER_IS_RUNNING)
- gdk_profiler_end_mark (before, "icon theme load", self->current_theme);
+ gdk_profiler_end_mark (before, "icon theme load", self->current_theme);
if (was_valid)
queue_theme_changed (self);
if (icon->texture)
return;
- before = g_get_monotonic_time ();
+ before = GDK_PROFILER_CURRENT_TIME;
/* This is the natural pixel size for the requested icon size + scale in this directory.
* We precalculate this so we can use it as a rasterization size for svgs.
if (GDK_PROFILER_IS_RUNNING)
{
- guint64 end = g_get_monotonic_time ();
+ gint64 end = GDK_PROFILER_CURRENT_TIME;
/* Don't report quick (< 0.5 msec) parses */
- if (end - before > 500 || !in_thread)
- gdk_profiler_add_markf (before, (end - before), in_thread ? "icon load (thread)" : "icon load" ,
- "%s size %d@%d", icon->filename, icon->desired_size, icon->desired_scale);
+ if (end - before > 500000 || !in_thread)
+ {
+ gdk_profiler_add_markf (before, (end - before), in_thread ? "icon load (thread)" : "icon load" ,
+ "%s size %d@%d", icon->filename, icon->desired_size, icon->desired_scale);
+ }
}
}
gpointer task_data,
GCancellable *cancellable)
{
- guint64 before = g_get_monotonic_time ();
+ gint64 before G_GNUC_UNUSED;
+
+ before = GDK_PROFILER_CURRENT_TIME;
if (g_task_return_error_if_cancelled (task))
return;
gtk_im_context_simple_init_compose_table ();
- if (GDK_PROFILER_IS_RUNNING)
- gdk_profiler_end_mark (before, "im compose table load (thread)", NULL);
+ gdk_profiler_end_mark (before, "im compose table load (thread)", NULL);
}
static void
GskRenderer *renderer;
GskRenderNode *root;
double x, y;
- gint64 before_snapshot = g_get_monotonic_time ();
- gint64 before_render = 0;
+ gint64 before_snapshot G_GNUC_UNUSED;
+ gint64 before_render G_GNUC_UNUSED;
+
+ before_snapshot = GDK_PROFILER_CURRENT_TIME;
+ before_render = 0;
if (!GTK_IS_NATIVE (widget))
return;
if (GDK_PROFILER_IS_RUNNING)
{
- before_render = g_get_monotonic_time ();
+ before_render = GDK_PROFILER_CURRENT_TIME;
gdk_profiler_add_mark (before_snapshot, (before_render - before_snapshot), "widget snapshot", "");
}
gsk_render_node_unref (root);
- if (GDK_PROFILER_IS_RUNNING)
- gdk_profiler_end_mark (before_render, "widget render", "");
+ gdk_profiler_end_mark (before_render, "widget render", "");
}
}
gtk_window_native_check_resize (GtkNative *native)
{
GtkWidget *widget = GTK_WIDGET (native);
- gint64 before = g_get_monotonic_time ();
+ gint64 before G_GNUC_UNUSED;
+
+ before = GDK_PROFILER_CURRENT_TIME;
if (!_gtk_widget_get_alloc_needed (widget))
gtk_widget_ensure_allocate (widget);
else if (gtk_widget_get_visible (widget))
gtk_window_move_resize (GTK_WINDOW (native));
- if (GDK_PROFILER_IS_RUNNING)
- gdk_profiler_end_mark (before, "size allocation", "");
+ gdk_profiler_end_mark (before, "size allocation", "");
}
static void
fallback: ['sysprof', 'libsysprof_capture_dep'],
)
if profiler_dep.found()
- cdata.set('HAVE_SYSPROF_CAPTURE', profiler_dep.found())
+ cdata.set('HAVE_SYSPROF', profiler_dep.found())
else
error('Profiler support not found, but was explicitly requested.')
endif
projects / gtk4.git / commitdiff